home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #4 / Amiga Plus CD - 2000 - No. 4.iso / Tools / Emulatoren / UAE0.6.4 / src / uaelib.c < prev    next >
C/C++ Source or Header  |  2000-05-27  |  14KB  |  682 lines
  1. /*
  2.  * UAE - The U*nix Amiga Emulator
  3.  * 
  4.  * UAE Library v0.1
  5.  * 
  6.  * (c) 1996 Tauno Taipaleenmaki <tataipal@raita.oulu.fi>
  7.  *
  8.  * Change UAE parameters and other stuff from inside the emulation. Creates
  9.  * a library called "uae.library" before the boot-up. To check if emulation
  10.  * is running we simply try to open the library. 
  11.  * 
  12.  * NOTE: The VERY FIRST attempt to open the library will actually create
  13.  *       it, so you should always try to open it twice.
  14.  * 
  15.  * Functions:            Offset  Purpose                      Arguments
  16.  * ----------
  17.  * D0 = GetVersion()      -0x1E Returns UAE version               -
  18.  * D0 = GetUaeConfig(A0)  -0x24 Get UAE Configuration       Pointer to memory
  19.  *                                                          block with the size
  20.  *                                                          of sizeof(UaeCfg)
  21.  *!D0 = SetUaeConfig(A0)  -0x2A Sets UAE Configuration      Pointer to struct
  22.  *                                                          UAE_CONFIG
  23.  *!D0 = HardReset()       -0x30 Resets the Amiga                  - 
  24.  *!D0 = Reset()           -0x36  -- "" --                         -
  25.  * D0 = EjectDisk(D0)     -0x3C Ejects a disk               D0 = Drive Number
  26.  * D0 = InsertDisk(A0,D0) -0x42 Inserts a disk              D0 = drive number,
  27.  *                                                          A0 = ptr to name
  28.  * D0 = EnableSound()     -0x48 Enables SOUND (if it was          -
  29.  *                              compiled in)       
  30.  * D0 = DisableSound()    -0x4E Disables SOUND                    -
  31.  * D0 = EnableJoystick()  -0x54 Enables FAKE_JOYSTICK             -
  32.  * D0 = DisableJoystick() -0x5A Disables FAKE_JOYSTICK            -
  33.  * D0 = SetFrameRate(D0)  -0x60 Changes frame rate          D0 = Framerate
  34.  *!D0 = ChgCMemSize(D0)   -0x66 Changes ChipMemSize         D0 = New Mem Size
  35.  *                              (DOES A HARD RESET!)
  36.  *!D0 = ChgSMemSize(D0)   -0x6C Changes SlowMemSize         D0 = New Mem Size
  37.  *                              (DOES A HARD RESET!)
  38.  *!D0 = ChgFMemSize(D0)   -0x72 Changes FastmemSize         D0 = New Mem Size
  39.  *                              (DOES A HARD RESET!)
  40.  * D0 = ChangeLanguage(D0)-0x78 Changes kbd lang.           D0 = Language 
  41.  * D0 = ExitEmu()         -0x7E Exits the emulator                -
  42.  * D0 = GetDisk(D0,A0)    -0x84 Gets the disks name         D0 = Drive
  43.  *                                                          A0 = Space for name
  44.  * D0 = Debug()           -0x8A Enters internal debugger          -
  45.  * ! means not implemented yet 
  46.  */
  47.  
  48. #include "sysconfig.h"
  49. #include "sysdeps.h"
  50.  
  51. #include <assert.h>
  52. #include <string.h>
  53.  
  54. #include "config.h"
  55. #include "options.h"
  56. #include "memory.h"
  57. #include "custom.h"
  58. #include "newcpu.h"
  59. #include "xwin.h"
  60. #include "autoconf.h"
  61. #include "disk.h"
  62. #include "os.h"
  63.  
  64. extern int quit_program;
  65.  
  66. static ULONG LibBase;
  67.  
  68. static ULONG opencount=0;
  69. static ULONG emulibname, functable,resname,resid, datatable;
  70. static CPTR GetVersion,HardReset,Reset,EnableSound,DisableSound,
  71.             EnableJoystick,DisableJoystick,SetFrameRate,ChangeLanguage,
  72.             ChgCMemSize,ChgSMemSize,ChgFMemSize,EjectDisk,InsertDisk,
  73.             ExitEmu, GetUaeConfig, SetUaeConfig,Open,Close,Expunge,Null,
  74.             GetDisk,FakeInit,segList,DebugFunc;
  75.  
  76. /*
  77.  * Library "open"
  78.  */
  79. static ULONG emulib_Open(void)
  80. {
  81.        opencount++;
  82.        put_word( LibBase + 32, get_word( LibBase + 32) + 1 );
  83.        return LibBase;
  84. }
  85.  
  86. static ULONG emulib_Close(void)
  87. {
  88.        if (opencount <= 1)
  89.      return 0;
  90.        else {
  91.           opencount--;
  92.           put_word( LibBase + 32, get_word( LibBase + 32) - 1 );
  93.           return 0;
  94.        }
  95. }
  96. static ULONG emulib_Expunge(void)
  97. {
  98.        return 0;
  99. }
  100.  
  101. static ULONG emulib_Null(void)
  102. {
  103.        return 0;
  104. }
  105.  
  106. /*
  107.  * Returns UAE Version
  108.  */
  109. static ULONG emulib_GetVersion(void)
  110. {
  111.        return version;
  112. }
  113.  
  114. /*
  115.  * Resets your amiga
  116.  * 
  117.  * DOES NOT WORK YET ! It obviously crashes when this routine returns().. ?
  118.  */
  119. static ULONG emulib_HardReset(void)
  120. {
  121.        m68k_reset();
  122.        return 0;
  123. }
  124.  
  125. static ULONG emulib_Reset(void)
  126. {
  127.        m68k_reset();
  128.        return 0;
  129. }
  130.  
  131. /*
  132.  * Enables SOUND
  133.  */
  134. static ULONG emulib_EnableSound(void)
  135. {
  136.     if (!sound_available || produce_sound == 2)
  137.     return 0;
  138.  
  139.     produce_sound = 2;
  140.     return 1;
  141. }
  142.  
  143. /*
  144.  * Disables SOUND
  145.  */
  146. static ULONG emulib_DisableSound(void)
  147. {
  148.     produce_sound = 1;
  149.     return 1;
  150. }
  151.  
  152. /*
  153.  * Enables FAKE JOYSTICK
  154.  */
  155. static ULONG emulib_EnableJoystick(void)
  156. {
  157.     fake_joystick = 1;
  158.     return 1;
  159. }
  160.  
  161. /*
  162.  * Disables FAKE JOYSTICK
  163.  */
  164. static ULONG emulib_DisableJoystick(void)
  165. {
  166.        fake_joystick = 0;
  167.        return 1;
  168. }
  169.  
  170. /*
  171.  * Sets the framerate
  172.  */
  173. static ULONG emulib_SetFrameRate(void)
  174. {
  175.     if (regs.d[0] == 0)
  176.     return 0;
  177.     else if (regs.d[0] > 20)
  178.     return 0;
  179.     else {
  180.     framerate = regs.d[0];
  181.     return 1;
  182.     }
  183. }
  184.  
  185. /*
  186.  * Changes keyboard language settings
  187.  */
  188. static ULONG emulib_ChangeLanguage(void)
  189. {
  190.     if (regs.d[0] > 5)
  191.     return 0;
  192.     else {
  193.     switch( regs.d[0] ) {
  194.      case 0:
  195.         keyboard_lang = KBD_LANG_US;
  196.         break;
  197.      case 1:
  198.         keyboard_lang = KBD_LANG_DE;
  199.         break;
  200.      case 2:
  201.         keyboard_lang = KBD_LANG_SE;
  202.         break;
  203.      case 3:
  204.         keyboard_lang = KBD_LANG_FR;
  205.         break;
  206.      case 4:
  207.         keyboard_lang = KBD_LANG_IT;
  208.         break;
  209.      default:
  210.         break;
  211.     }
  212.     return 1;
  213.     }
  214. }
  215.  
  216. /*
  217.  * Changes CHIPMEMORY Size
  218.  *  (reboots)
  219.  * 
  220.  * DOES NOT WORK YET !  - The m68k_reset does not work from here
  221.  */
  222. static ULONG emulib_ChgCMemSize(void)
  223. {
  224.     ULONG memsize = regs.d[0];
  225.        
  226.     if (memsize != 0x80000 && memsize != 0x100000 && 
  227.     memsize != 0x200000) {
  228.     memsize = 0x200000;
  229.     fprintf(stderr, "Unsupported chipmem size!\n");
  230.     }
  231.     regs.d[0] = 0;
  232.     
  233.     chipmem_size = memsize;
  234.     m68k_reset();
  235.     return 1;
  236. }
  237.  
  238. /*
  239.  * Changes SLOWMEMORY Size
  240.  *  (reboots)
  241.  * 
  242.  * DOES NOT WORK YET! - the m68k_reset does not work from here
  243.  */
  244. static ULONG emulib_ChgSMemSize(void)
  245. {
  246.        ULONG memsize = regs.d[0];
  247.        
  248.        if (memsize != 0x80000 && memsize != 0x100000 &&
  249.        memsize != 0x180000 && memsize != 0x1C0000) {
  250.           memsize = 0;
  251.           fprintf(stderr, "Unsupported bogomem size!\n");
  252.        }
  253.        
  254.        regs.d[0] = 0;
  255.        bogomem_size = memsize;
  256.        m68k_reset();
  257.        return 1;
  258. }
  259.  
  260. /* 
  261.  * Changes FASTMEMORY Size
  262.  *  (reboots)
  263.  * 
  264.  * DOES NOT WORK YET! - the m68k_reset() does not work from here
  265.  */
  266. static ULONG emulib_ChgFMemSize(void)
  267. {
  268.        ULONG memsize = regs.d[0];
  269.        
  270.        if (memsize != 0x100000 && memsize != 0x200000 &&
  271.        memsize != 0x400000 && memsize != 0x800000) {
  272.           memsize = 0;
  273.           fprintf(stderr, "Unsupported fastmem size!\n");
  274.        }
  275.        regs.d[0] = 0;
  276.        fastmem_size = memsize;
  277.        m68k_reset();
  278.        return 0;
  279. }
  280.  
  281. /*
  282.  * Ejects a disk
  283.  */
  284. static ULONG emulib_EjectDisk(void)
  285. {
  286.     ULONG drive = regs.d[0];
  287.        
  288.     if (drive > 3)
  289.     return 0;
  290.     
  291.     disk_eject( drive );
  292.     return 1;
  293. }
  294.  
  295. /*
  296.  * Inserts a disk
  297.  */
  298. static ULONG emulib_InsertDisk(void)
  299. {
  300.     int    quit = 0,i=0,j;
  301.     char   real_name[256];
  302.     UBYTE  abyte;
  303.     ULONG drive = regs.d[0];
  304.     CPTR  name = regs.a[0];
  305.     FILE   *file;
  306.        
  307.     if (drive > 3)
  308.     return 0;
  309.  
  310.     if  (!disk_empty( drive )) {
  311.     disk_eject( drive );
  312.     }
  313.        
  314.     while( quit == 0 ) {
  315.     abyte = get_byte(name + i);
  316.     if (abyte == '\0') {
  317.         real_name[i++] = '\0';
  318.         quit = 1;
  319.     } else {
  320.         real_name[i++] = abyte;
  321.     }
  322.     }
  323.     j = strlen( real_name );
  324.     if (j <= 0 || j > 255)
  325.     return 0;
  326.  
  327.     if (!(file = fopen(real_name, "r")))
  328.     return 0;
  329.  
  330.     fclose(file);
  331.     disk_insert(drive, real_name);
  332.     return 1;
  333.  
  334. }
  335.  
  336. /*
  337.  * Exits the emulator
  338.  */
  339. static ULONG emulib_ExitEmu(void)
  340. {
  341.        broken_in = 1;
  342.        regs.spcflags |= SPCFLAG_BRK;
  343.        quit_program = 1;
  344.        return 1;
  345. }
  346.  
  347. /*
  348.  * Gets UAE Configuration
  349.  */
  350. static ULONG emulib_GetUaeConfig(void)
  351. {
  352.        int i,j;
  353.        CPTR place = regs.a[0];
  354.  
  355.        put_long(place     , version);
  356.        put_long(place +  4, chipmem_size);
  357.        put_long(place +  8, bogomem_size);
  358.        put_long(place + 12, fastmem_size);
  359.        put_long(place + 16, framerate);
  360.        put_long(place + 20, produce_sound);
  361.        put_long(place + 24, fake_joystick);
  362.        put_long(place + 28, keyboard_lang);
  363.        if (disk_empty(0))
  364.      put_byte(place + 32, 0);
  365.        else
  366.      put_byte(place + 32, 1);
  367.        if (disk_empty(1))
  368.      put_byte(place + 33, 0);
  369.        else
  370.      put_byte(place + 33, 1);
  371.        if (disk_empty(2))
  372.      put_byte(place + 34, 0);
  373.        else
  374.      put_byte(place + 34, 1);
  375.        if (disk_empty(3))
  376.      put_byte(place + 35, 0);
  377.        else
  378.      put_byte(place + 35, 1);
  379.        
  380.        for(i=0;i<256;i++) {
  381.           put_byte((place + 36 + i), df0[i]);
  382.           put_byte((place + 36 + i + 256), df1[i]);
  383.           put_byte((place + 36 + i + 512), df2[i]);
  384.           put_byte((place + 36 + i + 768), df3[i]);
  385.        }
  386.        return 1;
  387. }
  388.  
  389. /*
  390.  * Sets UAE Configuration
  391.  * 
  392.  * NOT IMPLEMENTED YET
  393.  */
  394. static ULONG emulib_SetUaeConfig(void)
  395. {
  396.        return 1;
  397. }
  398.  
  399. /*
  400.  * Gets the name of the disk in the given drive
  401.  */
  402. static ULONG emulib_GetDisk(void)
  403. {
  404.     int i;
  405.     if (regs.d[0] > 3) 
  406.     return 0;
  407.  
  408.     switch( regs.d[0] ) {
  409.      case 0:
  410.     for(i=0;i<256;i++) {
  411.         put_byte( regs.a[0] + i, df0[i] );
  412.     }
  413.     break;
  414.      case 1:
  415.     for(i=0;i<256;i++) {
  416.         put_byte( regs.a[0] + i, df1[i] );
  417.     }
  418.     break;
  419.      case 2:
  420.     for(i=0;i<256;i++) {
  421.         put_byte( regs.a[0] + i, df2[i] );
  422.     }
  423.     break;
  424.      case 3:
  425.     for(i=0;i<256;i++) {
  426.         put_byte( regs.a[0] + i, df3[i] );
  427.     }
  428.     break;
  429.      default:
  430.     break;
  431.     }
  432.     return 1;
  433. }
  434.  
  435. /*
  436.  * Enter debugging state
  437.  */
  438. static ULONG emulib_Debug(void)
  439. {
  440.     broken_in = 1;
  441.     regs.spcflags |= SPCFLAG_BRK;
  442.     return 1;
  443. }
  444.  
  445. static ULONG emulib_FakeInit(void)
  446. {
  447.     segList = regs.a[0];
  448.     return regs.d[0];
  449. }
  450.  
  451. /*
  452.  * Creates the UAE.library in memory
  453.  */
  454. static ULONG emulib_Init(void)
  455. {
  456.     ULONG tmp1, quit,i;
  457.     UBYTE bitti;
  458.     ULONG dosbase;
  459.  
  460.     if (LibBase != 0)
  461.     return 0;
  462.        
  463.     regs.a[0] = functable;
  464.     regs.a[1] = datatable;
  465.     regs.a[2] = FakeInit;
  466.     regs.d[0] = 1024;
  467.     regs.d[1] = 0;
  468.     tmp1 = CallLib(regs.a[6], -0x54);
  469.     if (tmp1 == 0) {
  470.     fprintf(stderr, "Cannot create UAE.library! ");
  471.     return 0;
  472.     }
  473.     regs.a[1] = tmp1;
  474.     CallLib(regs.a[6], -0x18c);
  475.     LibBase = tmp1;
  476. #if 0
  477.     regs.a[1] = ds("dos.library");
  478.     regs.d[0] = 0;
  479.     dosbase = CallLib(regs.a[6], -552);
  480.     printf("%08lx\n", dosbase);
  481. #endif
  482.     regs.d[0] = 1;
  483.     return 0;
  484. }
  485.  
  486.  
  487. /*
  488.  * Installs the UAE LIBRARY
  489.  */
  490. void emulib_install(void)
  491. {
  492.     ULONG begin, end, inittable, initroutine;
  493.     ULONG jotain, func_place, data_place, init_place;
  494.        
  495.     resname = ds("uae.library");
  496.     resid = ds("UAE library 0.1");
  497.        
  498.     begin = here();
  499.     dw(0x4AFC);
  500.     dl(begin);
  501.     dl(0);
  502.     dw(0x8001);
  503.     dw(0x0988);
  504.     dl(resname);
  505.     dl(resid);
  506.     dl(here() + 4);
  507.  
  508.     dl(1024);
  509.     func_place = here();
  510.     dl(0);
  511.     data_place = here();
  512.     dl(0);
  513.     init_place = here();
  514.     dl(0);
  515.  
  516. /* Code to set up our library */
  517.  
  518.     initroutine = here();
  519.     calltrap(deftrap(emulib_Init));
  520.     dw(RTS);
  521.        
  522.     /* Function table */
  523.     Open = here();
  524.     calltrap(deftrap(emulib_Open));
  525.     dw(RTS);
  526.        
  527.     Close = here();
  528.     calltrap(deftrap(emulib_Close));
  529.     dw(RTS);
  530.        
  531.     Expunge = here();
  532.     calltrap(deftrap(emulib_Expunge));
  533.     dw(RTS);
  534.        
  535.     Null = here();
  536.     dw(0x203c); dl(1);
  537.     dw(RTS);
  538.  
  539.     GetVersion = here();
  540.     calltrap(deftrap(emulib_GetVersion));
  541.     dw(RTS);
  542.        
  543.     GetUaeConfig = here();
  544.     calltrap(deftrap(emulib_GetUaeConfig));
  545.     dw(RTS);
  546.        
  547.     SetUaeConfig = here();
  548.     calltrap(deftrap(emulib_SetUaeConfig));
  549.     dw(RTS);
  550.  
  551.     HardReset = here();
  552.     calltrap(deftrap(emulib_HardReset));
  553.     dw(RTS);
  554.        
  555.     Reset = here();
  556.     calltrap(deftrap(emulib_Reset));
  557.     dw(RTS);
  558.        
  559.     EjectDisk = here();
  560.     calltrap(deftrap(emulib_EjectDisk));
  561.     dw(RTS);
  562.        
  563.     InsertDisk = here();
  564.     calltrap(deftrap(emulib_InsertDisk));
  565.     dw(RTS);
  566.        
  567.     EnableSound = here();
  568.     calltrap(deftrap(emulib_EnableSound));
  569.     dw(RTS);
  570.        
  571.     DisableSound = here();
  572.     calltrap(deftrap(emulib_DisableSound));
  573.     dw(RTS);
  574.        
  575.     EnableJoystick = here();
  576.     calltrap(deftrap(emulib_EnableJoystick));
  577.     dw(RTS);
  578.  
  579.     DisableJoystick = here();
  580.     calltrap(deftrap(emulib_DisableJoystick));
  581.     dw(RTS);
  582.        
  583.     SetFrameRate = here();
  584.     calltrap(deftrap(emulib_SetFrameRate));
  585.     dw(RTS);
  586.        
  587.     ChgCMemSize = here();
  588.     calltrap(deftrap(emulib_ChgCMemSize));
  589.     dw(RTS);
  590.        
  591.     ChgSMemSize = here();
  592.     calltrap(deftrap(emulib_ChgSMemSize));
  593.     dw(RTS);
  594.        
  595.     ChgFMemSize = here();
  596.     calltrap(deftrap(emulib_ChgFMemSize));
  597.     dw(RTS);
  598.        
  599.     ChangeLanguage = here();
  600.     calltrap(deftrap(emulib_ChangeLanguage));
  601.     dw(RTS);
  602.  
  603.     ExitEmu = here();
  604.     calltrap(deftrap(emulib_ExitEmu));
  605.     dw(RTS);
  606.  
  607.     GetDisk = here();
  608.     calltrap(deftrap(emulib_GetDisk));
  609.     dw(RTS);
  610.  
  611.     DebugFunc = here();
  612.     calltrap(deftrap(emulib_Debug));
  613.     dw(RTS);
  614.        
  615.     FakeInit = here();
  616.     calltrap(deftrap(emulib_FakeInit));
  617.     dw(RTS);
  618.        
  619.     functable = here();
  620.     dl(Open);
  621.     dl(Close);
  622.     dl(Expunge);
  623.     dl(Null);
  624.     dl(GetVersion);
  625.     dl(GetUaeConfig);
  626.     dl(SetUaeConfig);
  627.     dl(HardReset);
  628.     dl(Reset);
  629.     dl(EjectDisk);
  630.     dl(InsertDisk);
  631.     dl(EnableSound);
  632.     dl(DisableSound);
  633.     dl(EnableJoystick);
  634.     dl(DisableJoystick);
  635.     dl(SetFrameRate);
  636.     dl(ChgCMemSize);
  637.     dl(ChgSMemSize);
  638.     dl(ChgFMemSize);
  639.     dl(ChangeLanguage);
  640.     dl(ExitEmu);
  641.     dl(GetDisk);
  642.     dl(DebugFunc);
  643.     dl(0xFFFFFFFF);
  644.  
  645.     datatable = here();
  646.     dw(0xE000);
  647.     dw(0x0008);
  648.     dw(0x0900);
  649.     dw(0xC000);
  650.     dw(0x000A);
  651.     dl(resname);
  652.     dw(0xE000);
  653.     dw(0x000E);
  654.     dw(0x0600);
  655.     dw(0xD000);
  656.     dw(0x0014);
  657.     dw(0x0001);
  658.     dw(0xD000);
  659.     dw(0x0000);
  660.     dw(0x0000);
  661.     dw(0xC000);
  662.     dw(0x0018);
  663.     dl(resid);
  664.     dl(0x00000000);
  665.     
  666.     end = here();
  667.  
  668.     org(begin + 6);           /* Load END value */
  669.     dl(end);
  670.  
  671.     org(data_place);
  672.     dl(datatable);
  673.        
  674.     org(func_place);
  675.     dl(functable);
  676.  
  677.     org(init_place);
  678.     dl(initroutine);
  679.        
  680.     org(end);
  681. }
  682.